<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        function Node(data, left, right) {
            this.data = data;
            this.left = left;
            this.right = right;
        }

        Node.prototype = {
            show: function() {
                console.log(this.data);
            }
        }

        function Tree() {
            this.root = null;
        }

        Tree.prototype = {
            // 二叉树插入操作
            insert: function(data) {
                var node = new Node(data, null, null);
                // 1.无根结点
                // 如果根结点为空，把当前结点作为根结点，返回
                if (!this.root) {
                    this.root = node;
                    return;
                }
                // 2.已有根结点
                // 从根结点开始遍历
                var current = this.root;
                var parent = null;
                while (current) {
                    // 若当前结点不为空，则当前结点作为父结点
                    parent = current;
                    // 根据新结点的数据判断从父结点的左子树遍历还是右子树遍历
                    // 2.1. 新结点数据小于父结点
                    if (data < parent.data) {
                        // 则遍历父结点的左子树
                        current = current.left;
                        // 若左子树为空
                        if (!current) {
                            // 则把新结点插入到左边，并返回
                            parent.left = node;
                            return;
                        }
                        // 否则，继续while循环，把当前的左子树作为父结点继续遍历
                        // 2.2. 新结点数据小于父结点
                    } else {
                        // 则遍历父结点得右子树
                        current = current.right;
                        // 若右子树为空
                        if (!current) {
                            // 则把新结点插入到右边，并返回
                            parent.right = node;
                            return;
                        }
                        // 否则，继续while循环，把当前的右子树作为父结点继续遍历
                    }

                }
            },
            /*
            DLR--前序遍历（根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面 ）

            LDR--中序遍历（根在中，从左往右，一棵树的左子树永远在根前面，根永远在右子树前面）

            LRD--后序遍历（根在后，从左往右，一棵树的左子树永远在右子树前面，右子树永远在根前面）
            */
            // 前序遍历
            preorderTraversal: function(node) {
                if (node) {
                    node.show();
                    this.preorderTraversal(node.left);
                    this.preorderTraversal(node.right);
                }
            },
            // 中序遍历
            inorderTraversal: function(node) {
                if (node) {
                    this.inorderTraversal(node.left);
                    node.show();
                    this.inorderTraversal(node.right);
                }
            },
            // 后续遍历
            postorderTraversal: function(node) {
                if (node) {
                    this.postorderTraversal(node.left);
                    this.postorderTraversal(node.right);
                    node.show();
                }
            },
            getMin: function() {
                var current = this.root;
                while (current) {
                    if (!current.left) {
                        return current;
                    }
                    current = current.left;
                }
            },
            getMax: function() {
                var current = this.root;
                while (current) {
                    if (!current.right) {
                        return current;
                    }
                    current = current.right;
                }
            },
            getDeep: function(node, deep) {
                deep = deep || 0;
                if (node == null) {
                    return deep;
                }
                deep++;
                var dleft = this.getDeep(node.left, deep);
                var dright = this.getDeep(node.right, deep);
                return Math.max(dleft, dright);
            },
            // 树查找
            getNode: function(data, node) {
                if (node) {
                    if (data === node.data) {
                        return node;
                    } else if (data < node.data) {
                        return this.getNode(data, node.left);
                    } else {
                        return this.getNode(data, node.right);
                    }
                } else {
                    return null;
                }
            }
        }

        var t = new Tree();
        t.insert(3);
        t.insert(8);
        t.insert(1);
        t.insert(2);
        t.insert(5);
        t.insert(7);
        t.insert(6);
        t.insert(0);
        console.log(t);
        t.inorderTraversal(t.root);
        console.log(t.getMin(), t.getMax());
        console.log(t.getDeep(t.root, 0));
        console.log(t.getNode(5, t.root));
    </script>
</body>

</html>